home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr49 / cl181.zip / CL.HPF < prev    next >
Text File  |  1993-04-26  |  12KB  |  507 lines
  1. /*
  2.     cl.hpf -- Container Lite v 1.81 "form template"
  3.     (C) Copyright 1993  John Webster Small
  4.     All rights reserved
  5. */
  6.  
  7.  
  8. #ifndef   cl_hpp
  9. #include "cl.hpp"
  10. #endif
  11.  
  12.  
  13. /*  ITEM descriptors  */
  14.  
  15.  
  16. #if defined(ITEM_NO_STRM_OPS)
  17.     #if !defined(ITEM_NO_STRM_INSERT)
  18.         #define ITEM_NO_STRM_INSERT
  19.     #endif
  20.     #if !defined(ITEM_NO_STRM_EXTRACT)
  21.         #define ITEM_NO_STRM_EXTRACT
  22.     #endif
  23. #endif
  24.  
  25. #if defined(ITEM_NO_REL_STRM_OPS)
  26.     #if !defined(ITEM_NO_REL_OPS)
  27.         #define ITEM_NO_REL_OPS
  28.     #endif
  29.     #if !defined(ITEM_NO_STRM_INSERT)
  30.         #define ITEM_NO_STRM_INSERT
  31.     #endif
  32.     #if !defined(ITEM_NO_STRM_EXTRACT)
  33.         #define ITEM_NO_STRM_EXTRACT
  34.     #endif
  35. #endif
  36.  
  37. #if defined(ITEM_DEL_ONLY)
  38.     #if !defined(ITEM_NO_REL_OPS)
  39.         #define ITEM_NO_REL_OPS
  40.     #endif
  41.     #if !defined(ITEM_NO_ASSIGN)
  42.         #define ITEM_NO_ASSIGN
  43.     #endif
  44.     #if !defined(ITEM_NO_COPYINIT)
  45.         #define ITEM_NO_COPYINIT
  46.     #endif
  47.     #if !defined(ITEM_NO_STRM_INSERT)
  48.         #define ITEM_NO_STRM_INSERT
  49.     #endif
  50.     #if !defined(ITEM_NO_STRM_EXTRACT)
  51.         #define ITEM_NO_STRM_EXTRACT
  52.     #endif
  53. #endif
  54.  
  55. #if defined(ITEM_STRMABLE) || defined(ITEM_STRM_BASE)
  56.     #if !defined(ITEM_STRM_BASE)
  57.         #define ITEM_STRM_BASE ITEM_STRMABLE
  58.     #endif
  59.     #if !defined(ITEM_TEST_ASSIGN)
  60.         #define ITEM_TEST_ASSIGN
  61.     #endif
  62.     #if !defined(ITEM_CLONE)
  63.         #define ITEM_CLONE
  64.     #endif
  65.     #if !defined(ITEM_STRM_MUT_DELETE)
  66.         #define ITEM_STRM_MUT_DELETE
  67.     #endif
  68.     #if !defined(ITEM_LINK)
  69.         #define ITEM_LINK
  70.     #endif
  71.     #if !defined(ITEM_UNLINK)
  72.         #define ITEM_UNLINK
  73.     #endif
  74.     #if !defined(ITEM_STRM_INSERT)
  75.         #define ITEM_STRM_INSERT
  76.     #endif
  77.     #if !defined(ITEM_STRM_EXTRACT)
  78.         #define ITEM_STRM_EXTRACT
  79.     #endif
  80. #endif
  81.  
  82. #if defined(ITEM_NO_REL_OPS)
  83.  
  84. inline CLcmP(CL_D_cmP(CLcmP(cmP,ITEM)),void)
  85. { return CLcmPcast((cmP? cmP : CLcmP0(ITEM)),void); }
  86.  
  87. #else
  88.  
  89. // not really inline - gimmick to
  90. // define function in header!
  91. inline int CL_D_cmp(const ITEM * D1, const ITEM * D2)
  92. { return ((*D1 == *D2)? 0 : ((*D1 > *D2)? 1 : -1)); }
  93.  
  94. inline CLcmP(CL_D_cmP(CLcmP(cmP,ITEM)),void)
  95. { CLcmP(defaultCmP,ITEM) = CL_D_cmp;
  96.  return CLcmPcast((cmP? cmP : defaultCmP),void); }
  97.  
  98. #endif
  99.  
  100. #if defined(ITEM_TEST_ASSIGN)
  101.     inline void * CL_D_ASSIGN(ITEM * D,
  102.         ITEM * S)
  103.     { return (void *) 
  104.     ((*D = *(ITEM_STRM_BASE *)S)? D : 0); }
  105. #elif defined(ITEM_NO_ASSIGN)
  106.     inline void * CL_D_ASSIGN(ITEM * D,
  107.         ITEM *)
  108.     { return (void *) 0; }
  109. #else
  110.     inline void * CL_D_ASSIGN(ITEM * D,
  111.         ITEM * S)
  112.     { *D = *S; return (void *) D; }
  113. #endif
  114.  
  115. #if defined(ITEM_CLONE)
  116.     inline void * CL_D_NEW(ITEM * thiS)
  117.     { return (void *) thiS->clone(); }
  118. #elif defined(ITEM_NO_COPYINIT)
  119.     inline void * CL_D_NEW(ITEM *)
  120.     { return (void *) 0; }
  121. #else
  122.     inline void * CL_D_NEW(ITEM * thiS)
  123.     { return (void *) new ITEM(*thiS); }
  124. #endif
  125.  
  126. #if defined(ITEM_STRM_MUT_DELETE)
  127.     inline void CL_D_DELETE(ITEM * D)
  128.     { if (!D->RefCount()) delete D; }
  129. #else
  130.     inline void CL_D_DELETE(ITEM *D)
  131.     { delete D; }
  132. #endif
  133.  
  134. #if defined(ITEM_LINK)
  135.     inline int CL_D_LINK(ITEM * D, void * B)
  136.     { return D->link(B); }
  137. #else
  138.     inline int CL_D_LINK(ITEM *, void *)
  139.     { return 1; }
  140. #endif
  141.  
  142. #if defined(ITEM_UNLINK)
  143.     inline void CL_D_UNLINK
  144.     (ITEM * D, void * B)
  145.     { D->unlink(B); }
  146. #else
  147.     inline void CL_D_UNLINK(ITEM*, void *)
  148.     {}
  149. #endif
  150.  
  151.  
  152. #if defined(ITEM_STRM_INSERT)
  153.     inline ostream& operator<<(ostream& os,
  154.         ITEM ** D)
  155.     { return os << *(ITEM_STRM_BASE *)*D; }
  156. #elif defined(ITEM_NO_STRM_INSERT)
  157.     inline ostream& operator<<(ostream& os,
  158.         ITEM **) { return os; }
  159. #else
  160.     inline ostream& operator<<(ostream& os,
  161.         ITEM ** D)
  162.     { return os << **D << endm; }
  163. #endif
  164.  
  165. #if defined(ITEM_STRM_EXTRACT)
  166.     inline istream& operator>>(istream& is,
  167.         ITEM ** D)
  168.     {
  169.         ITEM_STRM_BASE * S;
  170.         is >> S;
  171.         *D = (ITEM *) S;
  172.         return is;
  173.     }
  174. #elif defined (ITEM_NO_STRM_EXTRACT)
  175.     inline istream& operator>>(istream& is,
  176.         ITEM **) { return is; }
  177. #else
  178.     inline istream& operator>>(istream& is,
  179.         ITEM ** D)
  180.     {
  181.         if ((*D = new ITEM()) != (ITEM *)0)
  182.             is >> **D >> nextm;
  183.         return is;
  184.     }
  185. #endif
  186.  
  187.  
  188. class CL : cl {
  189.  
  190.  
  191. protected:
  192.  
  193.     CL  (defaultConstructor)
  194.             : cl(defaultConstruct) {}
  195.     void     assign(CL& b)
  196.             { cl::assign(b); }
  197.     cl:: destruct;
  198.     virtual voidCmP DcmP(voidCmP cmP)
  199.             { return CLcmPcast(CL_D_cmP
  200.             (CLcmPcast(cmP,ITEM)),void); }
  201.     virtual  void * Dassign(void * D,
  202.             const void * S)
  203.             { return CL_D_ASSIGN
  204.             ((ITEM *)D,(ITEM *)S); }
  205.     virtual  void * Dnew(const void * D)
  206.             { return  CL_D_NEW
  207.             ((ITEM *)D); }
  208.     virtual  void   Ddelete(void * D)
  209.             { CL_D_DELETE((ITEM *)D); }
  210.     virtual  int    Dattach(void * D)
  211.             { return CL_D_LINK((ITEM *)D,
  212.             (void *) this); }
  213.     virtual  void   Ddetach(void * D)
  214.             { CL_D_UNLINK((ITEM *)D,
  215.             (void *) this); }
  216.     virtual     int    Dput(ostream& os, void * D)
  217.             { return ((os << (ITEM **) &D)?
  218.             1 : 0); }
  219.     virtual     void * Dget(istream& is)
  220.             { ITEM * D; is >> &D;
  221.             return (void *) D; }
  222.     virtual  int    put(ostream& os)
  223.             { return cl::put(os); }
  224.     virtual  int    get(istream& is)
  225.             { return cl::get(is); }
  226.     friend   ostream& operator<<(ostream& os,
  227.             CL& b);
  228.     friend   istream& operator>>(istream& is,
  229.             CL& b);
  230.     cl:: vforEach;
  231.  
  232.  
  233. public:
  234.  
  235. /*  Constructors and destructor  */
  236.  
  237.     CL (unsigned flags = CL_BIND_ONLY,
  238.         unsigned maxNodes = CL_MAXNODES,
  239.         unsigned limit = CL_LIMIT,
  240.         unsigned delta = CL_DELTA) :
  241.         cl(flags,maxNodes,limit,delta)
  242.         {}
  243.     CL (ITEM * argv[],
  244.         unsigned argc = 0U,
  245.         unsigned flags = CL_BIND_ONLY)
  246.         : cl((void **)argv,argc,flags)
  247.         {}
  248.     CL (CL& b) : cl(defaultConstruct)
  249.         { assign(b); }
  250.     CL& operator=(CL& b)
  251.         { assign(b); return *this; }
  252.     CL (const char * filename)
  253.         : cl(defaultConstruct)
  254.         { (void) cl::load(filename); }
  255.     int     load(const char * filename)
  256.         { return cl::load(filename); }
  257.     int     save(const char * filename)
  258.         { return cl::save(filename); }
  259.     ITEM ** vector(ITEM ** argv = (ITEM **)0,
  260.         unsigned argc = 0U)
  261.         { return (ITEM **)cl::
  262.         vector((void **)argv,argc); }
  263.     virtual ~CL() { destruct(); }
  264.  
  265.  
  266. /*  Housekeeping Primitives  */
  267.  
  268.     cl:: Limit;
  269.     cl:: setLimit;
  270.     cl:: pack;
  271.     cl:: Delta;
  272.     cl:: setDelta;
  273.     cl:: Nodes;
  274.     cl:: MaxNodes;
  275.     cl:: setMaxNodes;
  276.     cl:: vacancy;
  277.     cl:: vacancyNonElastic;
  278.     cl:: Flags;
  279.     cl:: setFlags;
  280.     cl:: resetFlags;
  281.     CL&  operator<<(CL&
  282.             (*manipulator)(CL&))
  283.             { return (manipulator?
  284.             (*manipulator)
  285.             (*this)    : *this); }
  286.  
  287.  
  288. /*  Elastic Array Primitives  */
  289.  
  290.     ITEM *   atIns(unsigned n, ITEM * D)
  291.             { return (ITEM *)cl::
  292.             atIns(n,(void *)D); }
  293.     ITEM *   atInsNew(unsigned n, const ITEM * D)
  294.             { return (ITEM *)cl::
  295.             atInsNew(n,(const void *)D); }
  296.     ITEM *   atRmv(unsigned n)
  297.             { return (ITEM *)cl::
  298.             atRmv(n); }
  299.     cl:: allRmv;
  300.     cl:: atDel;
  301.     ITEM *   atDelAsg(unsigned n, ITEM * D)
  302.             { return (ITEM *)cl::
  303.             atDelAsg(n,(void *)D); }
  304.     cl:: allDel;
  305.     cl:: allClr;
  306.     ITEM *   atPut(unsigned n, ITEM * D)
  307.             { return (ITEM *)cl::
  308.             atPut(n,(void *)D); }
  309.     ITEM *   atPutNew(unsigned n, const ITEM * D)
  310.             { return (ITEM *)cl::
  311.             atPutNew(n,(const void *)D); }
  312.     ITEM *   atPutAsg(unsigned n, const ITEM * D)
  313.             { return (ITEM *)cl::
  314.             atPutAsg(n,(const void *)D); }
  315.     ITEM *   atGet(unsigned n)
  316.             { return (ITEM *)cl::
  317.             atGet(n); }
  318.     ITEM *   operator[](unsigned n)
  319.             { return atGet(n); }
  320.     ITEM *   atGetAsg(unsigned n, ITEM * D)
  321.             { return (ITEM *)cl::
  322.             atGetAsg(n,(void *) D); }
  323.     ITEM *   atXchg(unsigned n, ITEM * D)
  324.             { return (ITEM *)cl::
  325.             atXchg(n,(void *) D); }
  326.     unsigned index(const ITEM * D)
  327.             { return cl::
  328.             index((const void *)D); }
  329.     void     forEach(CLapplY(B,ITEM), ...)
  330.             { va_list args;
  331.             va_start(args,B);
  332.             vforEach((voidApplY)B,args);
  333.             va_end(args); }
  334.  
  335.  
  336. /*  Stack - Deque - Queue Primitives  */
  337.  
  338.     ITEM *   push(ITEM * D)
  339.             { return (ITEM *)cl::
  340.             push((void *) D); }
  341.     ITEM *   pushNew(const ITEM * D)
  342.             { return (ITEM *)cl::
  343.             pushNew((const void *)D); }
  344.     ITEM *   pop()
  345.             { return (ITEM *)cl::
  346.             pop(); }
  347.     CL&  operator>>(ITEM *& D)
  348.             { D = atRmv(0U);
  349.             return *this; }
  350.     cl:: popDel;
  351.     ITEM *   popDelAsg(ITEM * D)
  352.             { return (ITEM *)cl::
  353.             popDelAsg((void *)D); }
  354.     ITEM *   top()
  355.             { return (ITEM *)cl::
  356.                 top(); }
  357.     ITEM *   topAsg(ITEM * D)
  358.             { return (ITEM *)cl::
  359.             topAsg((void *)D); }
  360.     ITEM *   insQ(ITEM * D)
  361.             { return (ITEM *)cl::
  362.             insQ((void *)D); }
  363.     CL&  operator<<(ITEM * D)
  364.             { atIns(Nodes(),D);
  365.                    return *this; }
  366.     ITEM *   insQNew(const ITEM * D)
  367.             { return (ITEM *)cl::
  368.             insQNew((const void *)D); }
  369.     ITEM *   unQ()
  370.             { return (ITEM *)cl::
  371.             unQ(); }
  372.     cl:: unQDel;
  373.     ITEM *   unQDelAsg(ITEM * D)
  374.             { return (ITEM *)cl::
  375.             unQDelAsg((void *)D); }
  376.     ITEM *   rear()
  377.             { return (ITEM *)cl::
  378.                 rear(); }
  379.     ITEM *   rearAsg(ITEM * D)
  380.             { return (ITEM *)cl::
  381.             rearAsg((void *)D); }
  382.  
  383.  
  384. /*  List (single and double linked) Primitives  */
  385.  
  386.     cl:: CurNode;
  387.     cl:: setCurNode;
  388.     ITEM *   ins(ITEM * D)
  389.             { return (ITEM *)cl::
  390.             ins((void *)D); }
  391.     ITEM *   insNew(const ITEM * D)
  392.             { return (ITEM *)cl::
  393.             insNew((const void *)D); }
  394.     ITEM *   rmv()
  395.             { return (ITEM *)cl::
  396.             rmv(); }
  397.     cl:: del;
  398.     ITEM *   delAsg(ITEM * D)
  399.             { return (ITEM *)cl::
  400.             delAsg((void *)D); }
  401.     ITEM *   put(ITEM * D)
  402.             { return (ITEM *)cl::
  403.             put((void *)D); }
  404.     ITEM *   putNew(const ITEM * D)
  405.             { return (ITEM *)cl::
  406.             putNew((const void *)D); }
  407.     ITEM *   putAsg(const ITEM * D)
  408.             { return (ITEM *)cl::
  409.             putAsg((const void *)D); }
  410.     ITEM *   get()
  411.             { return (ITEM *)cl::
  412.             get(); }
  413.     operator ITEM *()  { return get(); }
  414.     ITEM *   getAsg(ITEM * D)
  415.             { return (ITEM *)cl::
  416.             getAsg((void *)D); }
  417.     ITEM *   next()
  418.             { return (ITEM *)cl::
  419.             next(); }
  420.     ITEM *   operator++()
  421.             { return next(); }
  422.     ITEM *   nextAsg(ITEM * D)
  423.             { return (ITEM *)cl::
  424.             nextAsg((void *)D); }
  425.     ITEM *   prev()
  426.             { return (ITEM *)cl::
  427.             prev(); }
  428.     ITEM *   operator--()
  429.             { return prev(); }
  430.     ITEM *   prevAsg(ITEM * D)
  431.             { return (ITEM *)cl::
  432.             prevAsg((void *)D); }
  433.  
  434.  
  435. /* Priority Q, Set, Bag, Dictionary, Sort Primitives */
  436.  
  437.     cl:: Sorted;
  438.     cl:: unSort;
  439.     void     setCmP(CLcmP(cmP,ITEM)
  440.             = CLcmP0(ITEM))
  441.             { cl::setCmP
  442.             ((voidCmP)cmP); }
  443.     CLcmP(CmPfnc,ITEM) { return CLcmPcast
  444.             (cl::CmP(),ITEM); }
  445.     int      sort(CLcmP(cmP,ITEM)
  446.             = CLcmP0(ITEM))
  447.             { return cl::sort
  448.             ((voidCmP)cmP); }
  449.     ITEM *   insSort(ITEM * D)
  450.             { return (ITEM *)cl::
  451.             insSort((void *)D); }
  452.     ITEM *   insSortNew(const ITEM * D)
  453.             { return (ITEM *)cl::
  454.             insSortNew((const void *)D); }
  455.     ITEM *   insUnique(ITEM * D)
  456.             { return (ITEM *)cl::
  457.             insUnique((void *)D); }
  458.     ITEM *   insUniqueNew(const ITEM * D)
  459.             { return (ITEM *)cl::
  460.             insUniqueNew((const void *)D);}
  461.     ITEM *   findFirst(const ITEM * K)
  462.             { return (ITEM *)cl::
  463.             findFirst((const void *)K); }
  464.     ITEM *   findNext(const ITEM * K)
  465.             { return (ITEM *)cl::
  466.             findNext((const void *)K); }
  467.     ITEM *   findLast (const ITEM * K)
  468.             { return (ITEM *)cl::
  469.             findLast((const void *)K); }
  470.     ITEM *   findPrev(const ITEM * K)
  471.             { return (ITEM *)cl::
  472.             findPrev((const void *)K); }
  473.     unsigned findAll(const ITEM * K)
  474.             { return cl::
  475.             findAll((const void *)K); }
  476.  
  477.  
  478. };    /*  class CL  */
  479.  
  480.  
  481. inline ostream& operator<<(ostream& os, CL& b)
  482.     { (void) b.put(os); return os; }
  483.  
  484. inline istream& operator>>(istream& is, CL& b)
  485.     { (void) b.get(is); return is; }
  486.  
  487.  
  488. #undef ITEM
  489. #undef CL
  490.  
  491. #undef ITEM_NO_STRM_OPS
  492. #undef ITEM_NO_REL_STRM_OPS
  493. #undef ITEM_DEL_ONLY
  494.     #undef ITEM_NO_REL_OPS
  495.     #undef ITEM_NO_ASSIGN
  496.     #undef ITEM_NO_COPYINIT
  497.     #undef ITEM_NO_STRM_INSERT
  498.     #undef ITEM_NO_STRM_EXTRACT
  499. #undef ITEM_STRMABLE
  500.     #undef ITEM_TEST_ASSIGN
  501.     #undef ITEM_CLONE
  502.     #undef ITEM_LINK
  503.     #undef ITEM_UNLINK
  504.     #undef ITEM_STRM_INSERT
  505.     #undef ITEM_STRM_EXTRACT
  506. #undef ITEM_STRM_BASE
  507.